This invention relates generally to the field of data communications. More particularly, a system and method are provided for enabling the automatic evolution of remote procedure call structures in a distributed computing environment.
In many distributed computing environments, a client process communicates with a server process via a remote procedure call (RPC). As part of a call, a pre-defined RPC interface is invoked to describe a requested operation or set of data. For example, one RPC interface invocation may constitute a request for the creation of a new user session. Another invocation may constitute a request for a set of data. A RPC interface may include any number of input and output arguments. These arguments may be of different data types, including scalars (e.g., numbers, text) and pre-defined RPC record types containing fields of one or more data types.
When a client or server is configured with an application that employs RPCs, it is equipped with knowledge of a static set of pre-defined RPC interfaces and record types, such as the current versions at the time of configuration. However, RPC interfaces and record types evolve over time, thereby leaving different entities (e.g., clients, servers) with different sets or versions.
Thus, over time, new RPC interfaces and record types are created (e.g., to request different types of data) and existing ones are augmented with additional fields or parameters. For example, an input or output parameter may be added to an RPC interface, or a field may be added to an RPC record type. When a new RPC interface or record type is released, or an existing one is modified, it is impractical to attempt to update all entities with the new or modified entity.
An application developer must expend great care and effort to ensure that a client or server endowed with a modified RPC interface or record type is able to communicate with another entity using an older version. Applications have typically handled this problem in one of two ways. First, an application may employ a self-describing structure comprising name/value pairs or using a markup language such as XML (Extensible Markup Language) or HTML (Hypertext Markup Language). The self-describing structure might contain information, in addition to its data, that allows an older computing device to pick out the fields known to it and ignore others.
However, an application employing a self-describing structure can only handle low-level changes because the framework for exchanging a self-describing structure must remain the same. And, the use and exchange of self-describing structures greatly increases the amount of data/information that must be communicated, thereby decreasing efficiency.
Second, the application may include logic designed to deduce a common set of structures understood by two communicating computer systems, and exchange those structures. However, the use of specialized logic merely transfers complexity from the RPC infrastructure to the application.
Thus, evolving an RPC interface or record type while maintaining the ability for devices having different versions of the interface or record type to use one in an RPC call has become very difficult for developers.